% ch2.tex
% Dieses Werk ist unter einem Creative Commons Namensnennung-Keine kommerzielle Nutzung-Weitergabe
% unter gleichen Bedingungen 3.0 Deutschland Lizenzvertrag lizenziert. Um die Lizenz anzusehen, gehen Sie bitte
% zu http://creativecommons.org/licenses/by-nc-sa/3.0/de/ oder schicken Sie einen Brief an
% Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.


%\chapter{8 multiplied by 3.57 equals$\ldots$}\label{ch:8multipliedby3.57}
\chapter{8 multipliziert mit 3,57 ergibt\texorpdfstring{$\ldots$}{...}}\label{ch:8multipliedby3.57}

%What is 8 multiplied by 3.57?  You'd have to use a calculator, wouldn't you?  Well perhaps you're extremely smart and can do multiplication of fractions in your head---but that's not the point.  You can also do the same thing with the Python console. Start up the console again (see Chapter~\ref{ch:notallsnakeswillsquishyou} for more information, if you've skipped ahead for some strange reason), and once you see the prompt, type 8$*$3.57 and press the Enter key:
Was ergibt 8 mal 3,57?  Du müsstest einen Taschenrechner verwenden, oder? Oder du bist besonders gut im Kopfrechnen und kannst Multiplikationen mit Kommastellen im Kopf rechnen---aber das ist nicht der Punkt. Du kannst auch die Python Konsole dafür verwenden. Starte wieder die Konsole (siehe Kapitel~\ref{ch:notallsnakeswillsquishyou} für genauere Infos, falls du es aus seltsamen Gründen übersprungen hast), und wenn du den Prompt siehst, tippst du 8 $*$ 3.57 ein und drückst die Enter-Taste:

%\begin{listing}
%\begin{verbatim}
%Python 3.0 (r30:67503, Dec  6 2008, 23:22:48)
%Type "help", "copyright", "credits" or "license" for more information.
%>>> 8 * 3.57
%28.559999999999999
%\end{verbatim}
%\end{listing}

\begin{Verbatim}[frame=single]
Python 3.1.1+ (r311:74480, Nov  2 2009, 14:49:22)
[GCC 4.4.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 8 * 3.57
28.56
\end{Verbatim}

%The star (*), or asterisk key (shift 8 on some keyboards), is used for multiplication\index{multiplication}, instead of the normal times symbol (\textsf{X}) that you use at school (using the star key is necessary, otherwise how would the computer know whether you meant the letter \emph{x} or the multiplication symbol \textsf{X} ?).  How about an equation that's a bit more useful?
Die Sterntaste (*) wird anstelle des normalen Multiplikationszeichen\index{Operatoren!Multiplikation} \textsf{X} verwendet, welches du in der Schule verwendest. Die Sterntaste mußt du verwenden, damit der Computer weiß, ob du den Buchstaben \emph{x} oder das Multiplikationszeichen \textsf{X} meinst. Wie wäre es nun mit einer Rechnung, die etwas interessanter ist?

%Suppose you do chores once a week, for which you get \$5 pocket money, and you have a paper round which you do 5 times a week and get \$30---how much money would you earn in a year?
Nehmen wir an, du machst Hausarbeiten und bekommst 5 € Taschengeld dafür, trägst die Zeitung fünf mal die Woche aus und bekommst dafür 30 €---wie viel Geld würdest du in einem Jahr verdienen?

%% Probleme mit \begin{figure}[t] -> weggelassen
%\begin{figure}[t]
\begin{center}
\fbox{\colorbox{PaleBlue}{\parbox{.75\linewidth} {
%\subsection*{Python is broken!?!?}
\section*{Python ist kaputt!?!?}

%If you just picked up a calculator and entered 8 x 3.57 the answer showing on the display will be:\\
Wenn du gerade mit einem Taschenrecher 8 x 3.57 ausgerechnet hast, wird folgendes auf der Anzeige erscheinen:\\

\textsf{
28.56\\
}

\noindent
%Why is Python different?  Is it broken?\\
Warum gibt Python manchmal ein anderes Ergebnis aus?\\

\noindent
%Actually, no. The reason can be found in the way floating point\index{floating point} (fractional numbers with a decimal place) numbers are handled by the computer.  It's a complicated and somewhat confusing problem for beginners, so it's best to just remember that when you're working with fractions (i.e. with a decimal place on a number), \emph{sometimes} the result won't be exactly what you were expecting. This is true for multiplication, division, addition or subtraction.
%}}}
Eigentlich nicht. Der Grund warum manchmal die Kommastellen bei Python nicht bis aufs letzte Detail mit dem Ergebnis des Taschenrechners zusammenpassen, liegt in der Art wie Computer mit Fließkommazahlen\index{Fließkommazahlen} (Zahlen mit Kommastellen) umgehen. Es ist ein wenig kompliziert und für Anfänger verwirrend. Am besten man merkt sich, wenn man mit Kommazahlen arbeitet, das \emph{manchmal} das Ergebnis nicht exakt dem entspricht, was man erwarten würde. Das stimmt für Multiplikation, Division, Addition und auch Subtraktion.
}}}
\end{center}
%\end{figure}

%If we were writing that on paper, we might write something like:
Auf Papier würden wir folgendes schreiben:
\begin{verbatim}
(5 + 30) x 52
\end{verbatim}

%Which is \$5 + \$30 multiplied by 52 weeks in a year.  \begin{samepage}Of course, we're smart, and we know that 5 + 30 is 35, so the equation is really:
Das ist 5 € + 30 € multipliziert mit 52 Wochen im Jahr. \begin{samepage}Natürlich sind wir so schlau und wissen, dass 5 + 30 eigentlich 35 ergibt, und so ergibt sich die Formel:


\begin{verbatim}
35 x 52
\end{verbatim}
\end{samepage}

%Which is easy enough to do in a calculator, or on paper.  But we can do all of these calculations with the console as well:
Was einfach genug ist, es auf Papier oder im Taschenrechner zu rechnen. Aber wir können alles auch mit der Python Konsole erledigen.

\begin{Verbatim}[frame=single]
>>> (5 + 30) * 52
1820
>>> 35 * 52
1820
\end{Verbatim}

%So, what if you spend \$10 each week?  How much do you have left at the end of the year?  We could write the equation on paper a couple of different ways, but let's just type it into the console:
Was passiert also, wenn du jede Woche 10 € ausgibst? Wie viel hast du dann am Ende des Jahres übrig? Wir könnten die Formel auf Papier aufschreiben, aber probieren wir es in der Konsole.

\begin{Verbatim}[frame=single]
>>> (5 + 30 - 10) * 52
1300
\end{Verbatim}

%That's \$5 and \$30 minus \$10 multiplied by 52 weeks in the year.  And you'd have \$1300 left at the end of the year. Okay, so that's not looking all that useful so far.  We can do all of that with a calculator.  But we'll come back to this later and show how to make it much more useful.
Das sind 5 € plus 30 € minus 10 € multipliziert mit 52 Wochen im Jahr. Am Ende des Jahres wären 1300 € übrig. Gut, das ist jetzt immer noch nicht so besonders spannend. Das hätten wir auch alles mit einem Taschenrechner machen können. Aber wir kommen da nochmals zurück und zeigen, wie das noch nützlicher und spannender wird.

%You can do multiplication\index{multiplication} and addition\index{addition} (obviously), and subtraction\index{subtraction} and division\index{division} in the Python console, along with a bunch of other maths operations that we won't go into now.  For the moment the basic maths symbols for Python (actually they're called operators\index{operators}) are:
Du kannst in der Python Konsole Multipizieren\index{Operatoren!Multiplikation}, Addieren\index{Operatoren!Addition}, Substrahieren\index{Operatoren!Substraktion} und auch Dividieren\index{Operatoren!Division}, aber auch andere mathematische Funktionen verwenden, auf die wir später eingehen werden. Fürs Erste sind die wichtigsten mathematischen Symbole in Python (eigentlich heißen sie Operatoren\index{Operatoren}):

%\begin{center}
%\begin{tabular}{|c|c|}
%\hline
%+ & Addition \\
%\hline
%- & Subtraction \\
%\hline
%* & Multiplication \\
%\hline
%/ & Division \\
%\hline
%\end{tabular}
%\end{center}
\begin{center}
\begin{tabular}{|c|c|}
\hline
+ & Addition \\
\hline
- & Subtraktion \\
\hline
* & Multiplikation \\
\hline
/ & Division \\
\hline
\end{tabular}
\end{center}

%The reason the forward-slash (/) is used for division, is that it would be rather difficult to draw a division line (plus they didn't bother to put a division symbol $\div$ on the computer keyboard) as you're supposed to use for written equations.  For example if you had 100 eggs and 20 boxes, you might want to know how many eggs would go in each box, so you'd show dividing 100 into 20, by writing the following equation:
Der Grund warum auf Computern der Schrägstrich (/) für die Division verwendet wird, ist der, dass es das Divisionssymbol $\div$ nicht auf die Tastatur geschafft hat. Wenn du als Beispiel 100 Eier und 20 Schachteln hättest, dann möchtest du vielleicht wissen wie viele Eier du pro Schachtel einpacken kannst. Du würdest folgendermaßen die 100 durch 20 dividieren:

\begin{displaymath}
\frac{100}{20}
\end{displaymath}

%Or if you know about long division, you might write it out fully like this:
%Diese Schreibweise der Division entspricht nicht der gewohnten Deutschen.

%\begin{displaymath}
%\longdiv{100}{20}
%\end{displaymath}

%Or you might even write it like this:
Oder du könntest es folgendermaßen schreiben:

\begin{displaymath}
100 \div 20
\end{displaymath}

%However, in Python terms you would just type it as ``100 / 20''.
In Python würdest du die Division aber so notieren ``100 / 20''.

%\emph{Which is much easier, I think.  But then, I'm a book---what do I know?}
\emph{Das ist auch viel einfacher denke ich. Aber was weiß ich schon. Ich bin nur ein Buch.}

%\section{Use of brackets and ``Order of Operations''}\index{order of operations}
\section{Verwendung von Klammern und die ``Reihenfolge der Operationen''}\index{Operatoren!Reihenfolge von Operatoren}

%We use brackets in a programming language to control what is called ``Order of Operations''.  An operation is the use of an operator (one of those symbols in the table above).  There are more operators than those basic symbols, but for that simple list (addition, subtraction, multiplication and division), it's enough to know that multiplication and division both have a higher order than addition and subtraction.  Which means you do the multiplication or division part of an equation before you do the addition or subtraction part.  In the following equation, all the operators are addition (+), the numbers are added in order:
Wir verwenden Klammern in Programmiersprachen um die ``Reihenfolge der Operationen'' zu bestimmen. Bei einer Operation verwendet man Operatoren (einen aus der Liste von vorhin). Es gibt mehr Operatoren als in der kurzen Liste stehen, aber fürs Erste genügt zu wissen, dass Multiplikation und Division einen höheren Rang haben als Addition und Subtraktion. Das bedeutet, dass du in einer Rechnung zuerst den Teil mit der Multiplikation und Division berechnest und dann erst die Addition und Subtraktion. In der folgenden Formel kommen nur Additionen vor (+) und die Zahlen werden der Reihenfolge nach addiert:

\begin{Verbatim}[frame=single]
>>> print(5 + 30 + 20)
55
\end{Verbatim}

\noindent
%Similarly, in this equation, there are only addition and subtraction operators, so again Python considers each number in the order it appears:
In der nächsten Formel gibt es nur Addition und Subtraktion. Deswegen betrachtet Python die Zahlen einfach der Reihe nach wie sie dastehen:

\begin{Verbatim}[frame=single]
>>> print(5 + 30 - 20)
15
\end{Verbatim}

\noindent
%But in the following equation, there is a multiplication operator, so the numbers 30 and 20 are considered first.  The equation is another way of saying, ``multiply 30 by 20, then add 5 to the result'' (multiplication first, because it has a higher order than addition):
Aber in der folgenden Formel gibt es zusätzlich noch eine Multiplikation. Deswegen werden die Zahlen 30 und 20 zuerst behandelt. Anstatt die Formel aufzuschreiben, könnte man sagen: ``multipliziere 30 mit 20 und addiere 5 zum Ergebnis'' (die Multiplikation kommt zuerst, weil sie einen höheren Rang hat als die Addition):

\begin{Verbatim}[frame=single]
>>> print(5 + 30 * 20)
605
\end{Verbatim}

\noindent
%So what happens when we add brackets?  The following equation shows the result:
Und wenn wir Klammern hinzufügen? Dann schaut es so aus:

\begin{Verbatim}[frame=single]
>>> print((5 + 30) * 20)
700
\end{Verbatim}

\noindent
%Why is the number different?  Because brackets control the order of operations.  With brackets, Python knows to calculate using the operators in the brackets first, then do the operators outside.  So that equation is another way of saying, ``add 5 and 30, then multiply the result by 20''.
Warum kommt jetzt ein anderes Ergebnis raus? Weil Klammern die Reihenfolge der Berechnung bestimmen. Wenn es Klammern gibt, rechnet Python den Inhalt der Klammern zuerst, dann erst den Rest außerhalb der Klammer. Somit könnte man anstatt der Formel auch sagen: ``Addiere 5 zu 30 und das Ergebnis wird mit 20 multipliziert''.
%The use of brackets can become more complicated.  There can be brackets inside brackets:
Die Verwendung von Klammern kann auch komplizierter werden. Es können Klammern innerhalb von Klammern stehen.

\begin{Verbatim}[frame=single]
>>> print(((5 + 30) * 20) / 10)
70
\end{Verbatim}

\noindent
%In this case, Python evaluates the \textbf{inner} most brackets first, then the outer brackets, and then the other operator.  So this equation is a way of saying, ``add 5 and 30, then multiply the result by 20, finally divide that result by 10''.  The result without brackets is again slightly different:
In diesem Fall wird Python zuerst die \textbf{innerste} Klammer ausrechnen, dann die äußere Klammern und dann den übrigen Operator behandeln. Hier könnte man sagen: ``Addiere 5 und 30, multipliziere das Ergebnis mit 20 und das Ergebnis wird dann durch 10 dividiert''. Das Ergebnis ohne Klammern wäre verschieden.

\begin{Verbatim}[frame=single]
>>> 5 + 30 * 20 / 10
65
\end{Verbatim}

%In this case 30 is multiplied by 20 first, then the result is divided by 10, finally 5 is added to the final result.
Ohne Klammern wird zuerst 30 mit 20 multipliziert, das Ergebnis durch 10 dividiert und am Ende kommt 5 dazu.

%\emph{Remember that multiplication and division always go before addition and subtraction, unless brackets are used to control the order of operations.}
\emph{Merke dir einfach, dass Multiplikation und Division immer vor Addition und Subtraktion kommen, außer es werden Klammern verwendet, die als erste behandelt werden. (Merksatz: Punkt vor Strichrechnung.}

%\section{There's nothing so fickle as a variable}\index{variable}
\section{Es gibt nichts unbeständigeres als eine Variable}\index{Variablen}

%A `variable' is a programming term used to describe a place to store things.  The `things' can be numbers, or text, or lists of numbers and text---and all sorts of other items too numerous to go into here.  For the moment, let's just think of a variable as something a bit like a mailbox.
Eine `Variable' ist ein Platz zum Speichern von Dingen. Diese `Dinge' können Nummern, Text, Listen von Zahlen oder auch eine Vielzahl von anderen Dingen sein. Eine Variable ist so etwas wie ein Briefkasten.

\begin{center}
\includegraphics*[width=76mm]{images/girlbubble}
\end{center}

%You can put things (such as a letter or a package) in a mailbox, just as you can put things (numbers, text, lists of numbers and text, etc, etc, etc) in a variable.  This mailbox idea is the way many programming languages work.  But not all.
Du kannst verschiedene Dinge in den Briefkasten werfen wie einen Brief oder ein Paket, so wie man Dinge (Nummern, Text, Listen von Zahlen und so weiter, und so weiter) in einer Variable speichert. So wie dieser Briefkasten funktionieren viele Programmiersprachen. Aber nicht alle.

%In Python, variables are slightly different.  Rather than being a mailbox with things in it, a variable is more like a label which is stuck on the outside of the mailbox.  We can pull that label off and stick it on something else, or even tie the label (perhaps with a piece of string) to more than one thing. We create a variable by giving it a name, using an equals sign (=), then telling Python what we want that name to point to.  For example:
In Python sind Variablen etwas verschieden. Eine Variable ist weniger ein Briefkasten sondern viel mehr die Beschriftung auf dem Briefkasten drauf. Du kannst die Beschriftung wegnehmen und woanders draufkleben oder sogar (mit der Hilfe von einem Faden) mit mehreren Dingen verbinden. Wir erzeugen eine Variable indem wir ihr einen Namen geben und das Gleichheitszeichen (=) verwenden. Damit sagen wir Python wohin der Name zeigen soll. Zum Beispiel:

%\begin{listing}
%\begin{verbatim}
%>>> fred = 100
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = 100
\end{Verbatim}

%We've just created a variable called `fred' and said that it points to the number 100.  It's a bit like telling Python to remember that number because we want to use it later.  To find out what a variable is pointing at, we can just type `print' in the console, followed by the variable name, and hit the Enter key.  For example:
Wir haben eben die Variable `Fritz' erzeugt und gesagt, dass sie auf die Zahl 100 zeigen soll. Es ist ein wenig so wie wenn man Python sagt: merk dir diese Nummer, weil ich werde sie später nochmal brauchen. Um herauszufinden wohin die Variable zeigt, kannst du die Funktion `print' in der Python Konsole eingeben, gefolgt vom Variablenname. Drücke danach Enter (die Eingabetaste). Zum Beispiel:

%\begin{listing}
%\begin{verbatim}
%>>> fred = 100
%>>> print(fred)
%100
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = 100
>>> print(Fritz)
100
\end{Verbatim}
%We can also tell Python we want the variable \code{fred} to point at something else:
Wir können Python auch sagen, dass die Variable \code{Fritz} auf etwas anderes zeigen soll:

%\begin{listing}
%\begin{verbatim}
%>>> fred = 200
%>>> print(fred)
%200
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = 200
>>> print(Fritz)
200
\end{Verbatim}

\noindent
%On the first line we say we now want fred to point at the number 200.  Then, in the second line, we ask what fred is pointing at just to prove it changed. We can also point more than one name at the same item:
Auf der ersten Zeile sagen wir, dass Fritz auf die Nummer 200 zeigen soll. Auf der zweiten Zeile fragen wir Fritz, wohin er zeigt um zu beweisen, dass Fritz jetzt auf 200 zeigt. Es können auch mehrere Namen auf das gleiche Ding zeigen.

%\begin{listing}
%\begin{verbatim}
%>>> fred = 200
%>>> john = fred
%>>> print(john)
%200
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = 200
>>> Franz = Fritz
>>> print(Franz)
200
\end{Verbatim}

%In the code above, we're saying that we want the name (or label) \code{john} to point at the same thing \code{fred} is pointing to.
Im Code oben geben wir an, dass der Name (oder Beschriftung) \code{Franz} auf das gleiche Ding wie \code{Fritz} zeigen soll.
%Of course, `fred' isn't a very useful name for a variable.  It doesn't tell us anything about what it's used for.  A mailbox is easy---you use a mailbox for mail.  But a variable can have a number of different uses, and can point at a whole bunch of different things, so we usually want something more informative as its name.
Natürlich ist `Fritz' kein besonderers guter Name für eine Variable. Es sagt uns nichts darüber aus, wofür die Variable verwendet wird. Bei einem Postkasten ist es einfach. Der wird für die Post verwendet. Aber eine Variable kann auf ganz verschiedene Dinge zeigen. Deswegen werden wir normalerweise sinnvollere Namen verwenden.
\par
%Suppose you started up the Python console, typed `fred = 200', then went away---spent 10 years climbing Mount Everest, crossing the Sahara desert, bungy-jumping off a bridge in New Zealand, and finally, sailing down the Amazon river---when you came back to your computer, would you remember what that number 200 meant (and what it was for)?
Nehmen wir an, dass du eben die Python Konsole gestartet hast und `Fritz = 200' eingegeben hast. Dann gehst du für 10 Jahre auf Weltreise. Du wanderst durch die Sahara, bezwingst den Mount Everest und segelst über den Atlantik---danach kommst du wieder an deinen Computer zurück. Würdest du wissen wofür die Zahl 200 stand und wofür du sie verwendet hast?

\noindent
%\emph{I don't think I would.}
\emph{Das glaube ich nicht.}

\noindent
%I just made it up now, and I have no idea what `fred = 200' means (other than a \emph{name} pointing at the number \emph{200}).  So after 10 years, you'll have absolutely no chance of remembering.
Ich habe mir das alles gerade ausgedacht und weiß selber nicht was `Fritz = 200' bedeutet (außer einem \emph{Namen} der auf die Nummer \emph{200} zeigt). Nach 10 Jahren hast du überhaupt keine Chance dich an die Bedeutung zu erinnern.
\par
%Aha!  But, what if we called our variable: \emph{number\_of\_students}.
Aha! Aber was wäre wenn wir die Variable \emph{anzahl\_von\_studenten} getauft hätten?

%\begin{listing}
%\begin{verbatim}
%>>> number_of_students = 200
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> anzahl_von_studenten = 200
\end{Verbatim}

%We can do that because variable names can be made up of letters, numbers and (\_) underscores---although they cannot start with a number.  If you come back after 10 years, `number\_of\_students' still makes sense.  You can type:
Das können wir deshalb machen, weil Variablennamen aus normalen Buchstaben, Zahlen und Unterstrichen bestehen können. Das erste Zeichen darf aber keine Zahl sein. Wenn du nun nach 10 Jahren die Variable `anzahl\_von\_studenten' siehst, wird es immer noch Sinn machen. Du kannst dann folgendes eintippen:

%\begin{listing}
%\begin{verbatim}
%>>> print(number_of_students)
%200
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print(anzahl_von_studenten)
200
\end{Verbatim}

\noindent
%And you'll immediately know that we're talking about 200 students.  It's not always important to come up with meaningful names for variables.  You can use anything from single letters (such as `a') to large sentences; and sometimes, if you're doing something quick, a simple and short variable name is just as useful.  It depends very much upon whether you want to be able to look at that variable name later and figure out what on earth you were thinking at the time you typed it in.
Und du würdest sofort wissen, dass es sich um 200 Studenten handelt. Es ist nicht immer so wichtig sich sinnvolle Namen für Variablen auszudenken. Du kannst auch einzelne Buchstaben oder ganze Sätze verwenden; und manchmal, wenn man schnell etwas schreibt, sind kurze Namen genauso praktisch. Es hängt davon ab, ob du später nochmals in den Code reinschauen wirst und rausfinden willst, was du dir damals dabei gedacht hast.

%\begin{listing}
%\begin{verbatim}
%%this_is_also_a_valid_variable_name_but_perhaps_not_very_useful
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
das_ist_auch_eine_gueltige_variable_aber_vielleicht_nicht_so_praktisch
\end{Verbatim}

%\section{Using Variable}\index{Variables}
\section{Variablen verwenden}\index{Variablen}

%Now we know how to create a variable, how do we use it?  Remember that equation we came up with earlier?  The one to work out how much money you'd have left at the end of the year, if you earned \$5 a week doing chores, \$30 a week on a paper round, and spent \$10 per week.  So far we have:
Jetzt wissen wir wie man Variablen erzeugt. Aber wie wenden wir sie an? Erinnerst du dich an die Rechnung von früher? Die Berechnung wieviel Geld du am Ende des Jahres gespart haben würdest, wenn du 5 € für die Hausarbeit bekommst und 30 € fürs Zeitung austragen. 10 € pro Woche gibst du aus. Bis jetzt schaut das so aus:

\begin{Verbatim}[frame=single]
>>> print((5 + 30 - 10) * 52)
1300
\end{Verbatim}

\noindent
%What if we turn the first 3 numbers into variables?  Try typing the following:
Was, wenn wir die ersten drei Nummern in Variablen verwandeln? Probiere folgendes aus:

%\begin{listing}
%\begin{verbatim}
%>>> chores = 5
%>>> paper_round = 30
%>>> spending = 10
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Hausarbeit = 5
>>> Zeitung_austragen = 30
>>> Ausgaben = 10
\end{Verbatim}

\noindent
%We've just created variables named `chores', `paper\_round' and `spending'.  We can then re-type the equation to get:
Somit haben wir eben die Variablen `Hausarbeit', `Zeitung\_austragen' und `Ausgaben' angelegt. Nun können wir die Rechnung so schreiben:

%\begin{listing}
%\begin{verbatim}
%>>> print((chores + paper_round - spending) * 52)
%1300
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print((Hausarbeit + Zeitung_austragen - Ausgaben) * 52)
1300
\end{Verbatim}

%Which gives the exact same answer.  What if you get \$2 more per week, for doing extra chores.  Change the `chores' variable to 7, then hit the up-arrow key ($\uparrow$) on your keyboard a couple of times, until the equation re-appears, and hit the Enter key:
Es kommt genau das Gleiche raus. Wenn du nun 2 € mehr für die Hausarbeit bekommst, kannst du einfach die `Hausarbeit' Variable auf 7 setzen. Danach drückst du die `Pfeil nach oben Taste' ($\uparrow$) und wenn die Rechnung wieder erscheint, drückst du Enter.

%\begin{listing}
%\begin{verbatim}
%>>> chores = 7
%>>> print((chores + paper_round - spending) * 52)
%1404
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Hausarbeit = 7
>>> print((Hausarbeit + Zeitung_austragen - Ausgaben) * 52)
1404
\end{Verbatim}

%That's a lot less typing to find out that you now end up with \$1404 at the end of the year.  You can try changing the other variables, then hit the up-arrow to perform the calculation again, and see what effect it has.
Das bedeutet schon eine Menge weniger Tippen um herauszufinden dass am Ende des Jahres 1404 € übrig sind. Du kannst die anderen Variablen auch verändern und schauen wie sich das aufs Ergebnis der Rechnung auswirkt.

%\begin{listing}
%\begin{verbatim}
%If you spend twice as much money per week:
%>>> spending = 20
%>>> print((chores + paper_round - spending) * 52)
%884
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
Wenn du doppelt so viel in der Woche ausgibst:
>>> Ausgaben = 20
>>> print((Hausarbeit + Zeitung_austragen - Ausgaben) * 52)
884
\end{Verbatim}

%You're only left with \$884 savings at the end of the year. This is still only slightly useful.  We haven't hit really useful yet.  But for the moment, it's enough to understand that variables are used to store things.
So bleiben dir also 884 € am Ende des Jahres übrig. Fürs arbeiten mit Variablen ist es fürs erste ausreichend, wenn man versteht, dass Variablen zum Speichern von Dingen verwendet werden.

\noindent
%\emph{Think of a mailbox with a label on it!}
\emph{Denk an einen Postkasten der eine Beschriftung hat!}

%\section{A Piece of String?}\index{strings}
\section{Ein String?}\index{Strings}

%If you're paying attention, and not just skimming through looking for the good bits, you might remember I mentioned that variables can be used for all sorts of things---not just numbers. In programming, most of the time we call text a `string'. Which might seem a bit weird; but if you think that text is just `stringing together' (or joining together) a bunch of letters, perhaps it might make a little more sense.
Wenn du ein wenig aufpasst und die Seiten nicht nur flüchtig überfliegst, dann erinnerst du dich vielleicht, dass sich Variablen für alle möglichen Dinge eignen---nicht nur Zahlen. Beim Programmieren wird ein Text `String' benannt. Das klingt ein wenig ungewohnt; aber String ist das englische Wort für Schnur und so Wörter kann man sich als aufgefädelte Buchstaben vorstellen. Dann macht die Bezeichung `String' für Text vielleicht etwas mehr Sinn.

\noindent
%\emph{Then again, perhaps it doesn't.}
\emph{Aber vielleicht auch nicht.}

%In which case, all you need to know, is that a string is just a bunch of letters and numbers and other symbols put together in some meaningful way. All the letters, and numbers, and symbols in this book could make up a string.  Your name could be a string.  So could your home address.  The first Python program we created in Chapter \ref{ch:notallsnakeswillsquishyou}, used a string: `Hello World'.
In diesem Fall solltest du dir einfach merken, dass ein String eine Ansammlung von Buchstaben, Ziffern und anderen Zeichen ist, die irgendwie sinnvoll zusammenhängen. Alle diese Buchstaben, Ziffern und Symbole in diesem Buch könnten einen String ergeben. Dein Name könnte ein String sein. Oder auch deine Adresse. Das erste Python Programm, welches wir in Kapitel \ref{ch:notallsnakeswillsquishyou} geschrieben haben, verwendet den String `Hallo Welt'.

\par
%In Python, we create a string by putting quotes around the text.  So we can take our useless \code{fred} variable, and put a string inside it like this:
In Python erzeugen wir einen String indem wir Anführungszeichen um den Text angeben. Wir könnten unsere nutzlose \code{Fritz} Variable nehmen und mit einem String verbinden.

%\begin{listing}
%\begin{verbatim}
%>>> fred = "this is a string"
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = "Ja, das ist ein String"
\end{Verbatim}

\noindent
%And we can see what's inside the \code{fred} variable, by typing \code{print(fred)}:
Und wir können nachschauen, was in der Variable \code{Fritz} gespeichert ist, indem wir \code{print(Fritz)} eintippen.

%\begin{listing}
%\begin{verbatim}
%>>> print(fred)
%this is a string
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print(Fritz)
Ja, das ist ein String
\end{Verbatim}

\noindent
%We can also use single-quotes to create a string:
Wir können auch einfache Anführungszeichen verwenden, um einen String zu erstellen.

%\begin{listing}
%\begin{verbatim}
%>>> fred = 'this is yet another string'
%>>> print(fred)
%this is yet another string
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = 'Das ist jetzt ein anderer String'
>>> print(Fritz)
Das ist jetzt ein anderer String
\end{Verbatim}

%However, if you try to type more than one line of text for your string using a single quote (') or double quote ("), you'll get an error message in the console. For example, type the following line and hit Enter, and you'll get a fairly scary error message similar to the following:
Wenn du aber mehr als eine Zeile Text der Variable zuweisen willst und Einfache (') oder Doppelte (") Anführungstriche verwendest, wirst du folgenden Fehler in der Konsole sehen:

%\begin{listing}
%\begin{verbatim}
%>>> fred = "this is two
%  File "<stdin>", line 1
%    fred = "this is two
%                      ^
%SyntaxError: EOL while scanning string literal
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = "Dieser String hat jetzt zwei
  File "<stdin>", line 1
    Fritz = "Das sind jetzt zwei
                               ^
SyntaxError: EOL while scanning string literal
>>>
\end{Verbatim}

%\index{multi-line string}We'll talk more about errors later, but for the moment, if you want more than one line of text, you can use 3 single quotes:
\index{Strings!mehrzeilig}Wir werden die Fehler später noch genauer betrachten, aber wenn du fürs Erste Strings mit mehreren Zeilen haben willst, kannst du 3 einfache Anführungsstriche verwenden:

%\begin{listing}
%\begin{verbatim}
%>>> fred = '''this is two
%... lines of text in a single string'''
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Fritz = '''Das sind jetzt zwei
... Zeilen Text in einem einzigen String'''
\end{Verbatim}

\noindent
%Print out the contents to see if it worked:
Gib den Inhalt der Variable aus, um zu sehen, ob es funktioniert hat:

%\begin{listing}
%\begin{verbatim}
%>>> print(fred)
%this is two
%lines of text in a single string
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print (Fritz)
Das sind jetzt zwei
Zeilen Text in einem einzigen String
\end{Verbatim}

%By the way, you'll see those 3 dots (...) quite a few times when you're typing something that continues onto another line (like a multi line string).  In fact, you'll see it a lot more as we continue.
Ganz nebenbei: du wirst diese 3 Punkte (...) noch ein paar mal sehen, wenn du etwas eintippst, was sich über mehrere Zeilen zieht (wie ein mehrzeiliger String).

%\section{Tricks with Strings}\label{trickswithstrings}
\section{Tricks mit Strings}\label{trickswithstrings}

%Here's an interesting question:  what's 10 * 5 (10 times 5)?  The answer is, of course, 50.
Hier ist eine interessante Frage: was ergibt 10 * 5 (10 mal 5)? Die Antwort ist natürlich 50.

\noindent
%\emph{All right, that's not an interesting question at all.}
\emph{Gut, das war jetzt überhaupt nicht interessant.}

%But what is 10 * 'a' (10 times the letter a)?  It might seem like a nonsensical question, but here's the answer from the World of Python:
Aber was ist 10 * 'a' (10 mal der Buchstabe a)? Das ist eine komische Frage, aber hier kommt die Antwort aus der Python Welt.

\begin{Verbatim}[frame=single]
>>> print(10 * 'a')
aaaaaaaaaa
\end{Verbatim}

%This works with more than just single character strings:
Das geht auch mit Strings, die aus mehreren Zeichen bestehen:

\begin{Verbatim}[frame=single]
>>> print(20 * 'abcd')
abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
\end{Verbatim}

%Another trick with a string, is embedding values.  You can do this by using \%s, which is like a marker (or a placeholder) for a value you want to include in a string.  It's easier to explain with an example:
Ein anderer Trick mit Strings ist das Einbauen von Platzhaltern. Du kannst das machen indem du \%s verwendest, was genau einen Platz bereithält. Da könnte auch ein String darin Platz finden. Machen wir ein Beispiel.

%\begin{listing}
%\begin{verbatim}
%>>> mytext = 'I am %s years old'
%>>> print(mytext % 12)
%I am 12 years old
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> mein_text = 'Ich bin %s Jahre alt'
>>> print(mein_text % 12)
Ich bin 12 Jahre alt
\end{Verbatim}

%In the first line, the variable mytext is created with a string containing some words and a placeholder (\%s).  The \%s is a little beacon saying ``replace me with something'' to the Python console.  So on the next line, when we call \code{print(mytext)}, we use the \% symbol, to tell Python to replace the marker with the number 12. We can reuse that string and pass in different values:
In der ersten Zeile erzeugen wir die Variable mein\_text die einen String und einen Platzhalter (\%s) enthält. Das kleine Symbol \%s steht da und sagt zur Python Konsole: ``ersetze mich durch irgend etwas''. Also rufen wir in der nächsten Zeile den \code{print(mein\_text)} Befehl auf. Darin verwenden wir das \% Symbol und sagen Python das es den Platzhalter mit der Nummer 12 ersetzen soll. Den String können wir auch mit anderen Zahlen wiederverwenden.

%\begin{listing}
%\begin{verbatim}
%>>> mytext = 'Hello %s, how are you today?'
%>>> name1 = 'Joe'
%>>> name2 = 'Jane'
%>>> print(mytext % name1)
%Hello Joe, how are you today?
%>>> print(mytext % name2)
%Hello Jane, how are you today?
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> mein_text = 'Hallo %s, wie geht es dir heute?'
>>> name1 = 'Romeo'
>>> name2 = 'Julia'
>>> print(mein_text % name1)
Hallo Romeo, wie geht es dir heute?
>>> print(mein_text % name2)
Hallo Julia, wie geht es dir heute?
\end{Verbatim}

%In the above example, 3 variables (mytext, name1 and name2) are created---the first includes the string with the marker.  Then we can print the variable `mytext', and again use the \% operator to pass in variables `name1' and `name2'.  You can use more than one placeholder:
Im vorigen Beispiel haben wir 3 Variablen erzeugt (mein\_text, name1, name2). Die erste Variable enthält den Text mit dem Platzhalter. Danach geben wir die Variable aus und verwenden den Platzhalter \% um die Variablen `name1' und `name2' mitzugeben. Du kannst auch mehr als einen Platzhalter verwenden.

%\begin{listing}
%\begin{verbatim}
%>>> mytext = 'Hello %s and %s, how are you today?'
%>>> print(mytext % (name1, name2))
%Hello Joe and Jane, how are you today?
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> mein_text = 'Hallo %s und %s, wie geht es euch heute?'
>>> print(mein_text % (name1, name2))
Hallo Romeo und Julia, wie geht es euch heute?
\end{Verbatim}

%When using more than one marker, you need to wrap the replacement values with brackets---so (name1, name2) is the proper way to pass 2 variables. A set of values surrounded by brackets (the round ones, not the square ones) is called a \emph{tuple}, and is a little bit like a list, which we'll talk about next.
Wenn du mehr als einen Platzhalter verwendest, musst du die mitgegebenen Variablen mit Klammern einpacken---also (name1, name2) ist der richtige Weg um 2 Variablen mitzugeben. Man sagt zu so einem Set von Variablen in runden Klammern auch \emph{Tupel}, und es verhält sich ein wenig wie eine Liste. Darüber wollen wir jetzt reden.

%\section{Not quite a shopping list}\index{lists}
\section{Fast schon eine Einkaufsliste}\index{Listen}

%Eggs, milk, cheese, celery, peanut butter, and baking soda.  Which is not quite a full shopping list, but good enough for our purposes. If you wanted to store this in a variable you could create a string:
Eier, Milch, Käse, Sellerie, Honig und Backpulver. Das ist zwar noch nicht die gesamte Einkaufsliste, aber gut genug für unsere Zwecke. Wenn du das alles in einer Variable speichern willst, dann könnte es so ausschauen:

%\begin{listing}
%\begin{verbatim}
%>>> shopping_list = 'eggs, milk, cheese, celery, peanut butter, baking soda'
%>>> print(shopping_list)
%eggs, milk, cheese, celery, peanut butter, baking soda
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Einkaufsliste = 'Eier, Milch, Käse, Sellerie, Honig, Backpulver'
>>> print(Einkaufsliste)
Eier, Milch, Käse, Sellerie, Honig, Backpulver
\end{Verbatim}

%Another way would be to create a `list', which is a special kind of object in Python:
Die andere Möglichkeit ist es eine `Liste' zu erzeugen, die es in Python auch gibt.

%\begin{listing}
%\begin{verbatim}
%>>> shopping_list = [ 'eggs', 'milk', 'cheese', 'celery', 'peanut butter',
%... 'baking soda' ]
%>>> print(shopping_list)
%['eggs', 'milk', 'cheese', 'celery', 'peanut butter', 'baking soda']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Einkaufsliste = [ 'Eier', 'Milch', 'Käse', 'Sellerie',
...'Honig', 'Backpulver' ]
>>> print(Einkaufsliste)
['Eier', 'Milch', 'Käse', 'Sellerie', 'Honig', 'Backpulver']
\end{Verbatim}

%This is more typing, but it's also more useful.  We could print the 3rd item in the list by using its position (called its index position), inside square brackets []:
Da musst du schon mehr tippen. Aber dafür kann man mit dieser Liste auch mehr anstellen. Da könnte man gezielt das dritte Ding herauspicken (die dritte Position) und ausgeben. Mit Python funktioniert das mit den eckigen Klammern []:

%\begin{listing}
%\begin{verbatim}
%>>> print(shopping_list[2])
%cheese
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print(Einkaufsliste[2])
Käse
\end{Verbatim}

%Lists start at index position 0---so the first item in a list is 0, the second is 1, the third is 2.  That doesn't make a lot of sense to most people, but it does to programmers.  Pretty soon, when you walk up some stairs you'll start counting with zero rather than one.  That will really confuse your little brother or sister.
Listen beginnen mit der Position 0---also wird der erste Eintrag mit 0 angesprochen, der Zweite mit 1, der Dritte mit 2 und so weiter. Das macht für die meisten Leute keinen Sinn, aber es macht für Programmierer Sinn. Bald fängst du auch mit 0 zählen an, wenn du die Treppen einer Stiege zählst. Das wird deinen kleinen Bruder ziemlich verwirren.
\par
%We can show all the items from the 3rd item up to the 5th in the list, by using a colon inside the square brackets:
Wir können die Inhalte der Liste von der dritten bis zur fünften Position folgendermaßen ausgeben:

%\begin{listing}
%\begin{verbatim}
%>>> print(shopping_list[2:5])
%['cheese', 'celery', 'peanut butter']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> print(Einkaufsliste[2:5])
['Käse', 'Sellerie', 'Honig']
\end{Verbatim}

%[2:5] is the same as saying that we are interested in items from index position 2 up to (but not including) index position 5.  And, of course, because we start counting with 0, the 3rd item in the list is actually number 2, and the 5th item is actually number 4. Lists can be used to store all sorts of items.  They can store numbers:
Mit [2:5] sagen wir Python, dass uns die Position 2 bis 5 (aber 5 ist nicht dabei) interessiert. Und da wir ja mit 0 anfangen zu zählen, wird der dritte Eintrag mit 2 angesprochen und die fünfte Position ist in Python die Nummer 4. In Listen kann man alles mögliche speichern. Darin kann man Nummern speichern:

%\begin{listing}
%\begin{verbatim}
%>>> mylist = [ 1, 2, 5, 10, 20 ]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> meine_liste = [ 1, 2, 5, 10, 20 ]
>>> print(meine_liste)
\end{Verbatim}

\noindent
%And strings:
Und auch Strings:

%\begin{listing}
%\begin{verbatim}
%>>> mylist = [ 'a', 'bbb', 'ccccccc', 'ddddddddd' ]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> meine_liste = [ 'a', 'bbb', 'ccccccc', 'ddddddddd' ]
>>> print(meine_liste)
\end{Verbatim}

\noindent
%And mixtures of numbers and strings:
Oder auch eine Mischung von Zahlen und Strings:

%\begin{listing}
%\begin{verbatim}
%>>> mylist = [1, 2, 'a', 'bbb']
%>>> print(mylist)
%[1, 2, 'a', 'bbb']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> meine_liste = [1, 2, 'a', 'bbb']
>>> print(meine_liste)
[1, 2, 'a', 'bbb']
\end{Verbatim}

\noindent
%And even lists of lists:
Und sogar eine Liste von Listen:

%\begin{listing}
%\begin{verbatim}
%>>> list1 = [ 'a', 'b', 'c' ]
%>>> list2 = [ 1, 2, 3 ]
%>>> mylist = [ list1, list2 ]
%>>> print(mylist)
%[['a', 'b', 'c'], [1, 2, 3]]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 = [ 'a', 'b', 'c' ]
>>> liste2 = [ 1, 2, 3 ]
>>> meine_liste = [ liste1, liste2 ]
>>> print(meine_liste)
[['a', 'b', 'c'], [1, 2, 3]]
\end{Verbatim}

%In the above example, a variable called `list1' is created with 3 letters, `list2' is created with a 3 numbers, and `mylist' is created using list1 and list2. Things can get rather confusing, rather quickly, if you start creating lists of lists of lists of lists$\ldots$ but luckily there's not usually much need for making things that complicated in Python. Still it is handy to know that you can store all sorts of items in a Python list.
Im obigen Beispiel erzeugen wir eine Variable mit dem Namen `liste1' und speichern 3 Buchstaben darin. In `liste2' speichern wir 3 Zahlen. Die `meine\_liste' wird aus den Inhalten der Variablen `liste1' und `liste2' befüllt. Wenn man Listen von Listen erzeugt, werden die Dinge schnell etwas verwirrend. Zum Glück braucht man das nicht oft. Praktisch zu wissen ist jedoch, dass man alle möglichen Inhalte in Python Listen speichern kann.

\noindent
%\emph{And not just your shopping.}
\emph{Und nicht nur den nächsten Einkauf.}

%\subsection*{\color{BrickRed}Replacing items}\index{lists!replacing}
\subsection*{\color{BrickRed}Tausche Dinge aus}\index{Listen!Einträge austauschen}

%We can replace an item in the list, by setting its value in a similar way to setting the value of a normal variable. For example, we could change celery to lettuce by setting the value in index position 3:
Wir können einen Eintrag der Liste austauschen, indem wir ihm einen Wert zuweisen, wie wir das mit normalen Variablen tun. Zum Beispiel könnten wir Sellerie an Position 3 durch Bananen ersetzen.

%\begin{listing}
%\begin{verbatim}
%>>> shopping_list[3] = 'lettuce'
%>>> print(shopping_list)
%['eggs', 'milk', 'cheese', 'lettuce', 'peanut butter', 'baking soda']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Einkaufsliste[3] = 'Bananen'
>>> print(Einkaufsliste)
['Eier', 'Milch', 'Käse', 'Bananen', 'Honig', 'Backpulver']
\end{Verbatim}

%\subsection*{\color{BrickRed}Adding more items...}\index{lists!appending}
\subsection*{\color{BrickRed}Dinge hinzufügen...}\index{Listen!hinzufügen}

%We can add items to a list by using a method called `append'.  A method is an action or command that tells Python that we want to do something.  We'll talk more about methods later, but for the moment, to add an item to our shopping list, we can do the following:
Wir können aber auch Dinge an die Einkaufsliste dranhängen indem wir die Methode `append' benutzen. Eine Methode ist ein Kommando damit Python weiß was wir tun wollen. Wir kommen etwas später im Buch zu Methoden, aber zuerst schreiben wir noch ein Ding zur Einkaufliste dazu. Das geht so:

%\begin{listing}
%\begin{verbatim}
%>>> shopping_list.append('chocolate bar')
%>>> print(shopping_list)
%['eggs', 'milk', 'cheese', 'lettuce', 'peanut butter', 'baking soda',
%'chocolate bar']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> Einkaufsliste.append('Schokoriegel')
>>> print (Einkaufsliste)
['Eier', 'Milch', 'Käse', 'Bananen', 'Honig', 'Backpulver', 'Schokoriegel']
\end{Verbatim}

%Which, if nothing else, is certainly an improved shopping list.
Was die Liste schon um einiges verbessert hat.

%\subsection*{\color{BrickRed}$\ldots$and removing items}\index{lists!removing}
\subsection*{\color{BrickRed}$\ldots$und Dinge entfernen}\index{Listen!entfernen}


%We can remove items from a list by using the command `del' (short for delete).  For example, to remove the 6th item in the list (baking soda):
Wir können auch Einträge von der Liste streichen in dem wir das Kommando `del' (was eine Kurzform vom englischen delete ist und so viel heißt wie entfernen) verwenden.

%\begin{listing}
%\begin{verbatim}
%>>> del shopping_list[5]
%>>> print(shopping_list)
%['eggs', 'milk', 'cheese', 'lettuce', 'peanut butter', 'chocolate bar']
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> del Einkaufsliste[5]
>>> print (Einkaufsliste)
['Eier', 'Milch', 'Käse', 'Bananen', 'Honig', 'Schokoriegel']
\end{Verbatim}

%Remember that positions start at zero, so shopping\_list[5] actually refers to the 6th item.
Da die Positionen mit 0 anfängt, bedeutet Einkaufsliste[5] eigentlich den sechsten Eintrag.

%\subsection*{\color{BrickRed}2 lists are better than 1}\index{lists!joining}
\subsection*{\color{BrickRed}Zwei Listen sind besser als Eine}\index{Listen!zusammenfügen}

%We can join lists together by adding them, as if we were adding two numbers:
Wir können auch Listen verbinden, wie man zwei Nummern addiert:

%\begin{listing}
%\begin{verbatim}
%>>> list1 = [ 1, 2, 3 ]
%>>> list2 = [ 4, 5, 6 ]
%>>> print(list1 + list2)
%[1, 2, 3, 4, 5, 6]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 = [ 1, 2, 3 ]
>>> liste2 = [ 4, 5, 6 ]
>>> print(liste1 + liste2)
[1, 2, 3, 4, 5, 6]
\end{Verbatim}

\noindent
%We can also add the two lists and set the result to another variable:
Wir können auch zwei Listen zusammenfassen und das Ergebnis einer anderen Variable zuweisen:

%\begin{listing}
%\begin{verbatim}
%>>> list1 = [ 1, 2, 3 ]
%>>> list2 = [ 4, 5, 6 ]
%>>> list3 = list1 + list2
%>>> print(list3)
%[1, 2, 3, 4, 5, 6]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 = [ 1, 2, 3 ]
>>> liste2 = [ 4, 5, 6 ]
>>> liste3 = liste1 + liste2
>>> print(liste3)
[1, 2, 3, 4, 5, 6]
\end{Verbatim}

\noindent
%And you can multiply a list in the same way we multiplied a string:
Und du kannst auch eine Liste multiplizieren, wie damals einen String:

%\begin{listing}
%\begin{verbatim}
%>>> list1 = [ 1, 2 ]
%>>> print(list1 * 5)
%[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 = [ 1, 2 ]
>>> print(liste1 * 5)
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
\end{Verbatim}

\noindent
%In the above example, multiplying list1 by five is another way of saying ``repeat list1 five times''. However, division (/) and subtraction (-) don't make sense when working with lists, so you'll get errors when trying the following examples:
Im vorigen Beispiel wird die liste1 mit fünf multipliziert. Das ist ein anderer Weg um Python zu sagen ``Wiederhole Liste1 fünf mal''. Division (/) und Subtraktion (-) machen aber mit Listen keinen Sinn und du würdest einen Fehler wie diesen bekommen:

%\begin{listing}
%\begin{verbatim}
%>>> list1 / 20
%Traceback (most recent call last):
%  File "<stdin>", line 1, in <module>
%TypeError: unsupported operand type(s) for /: 'list' and 'int'
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 / 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'list' and 'int'
\end{Verbatim}

\noindent
%or:
oder

%\begin{listing}
%\begin{verbatim}
%>>> list1 - 20
%Traceback (most recent call last):
%  File "<stdin>", line 1, in <module>
%TypeError: unsupported operand type(s) for -: 'type' and 'int'
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> liste1 - 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'type' and 'int'
\end{Verbatim}

\noindent
%You'll get a rather nasty error message.
Du bekommst auf jeden Fall eine garstige Fehlermeldung.

%\section{Tuples and Lists}\label{tuplesandlists}\index{tuples}
\section{Tupel und Listen}\label{tuplesandlists}\index{Tupel}

%A tuple (mentioned earlier) is a little bit like a list, but rather than using square brackets, you use round brackets---e.g. `(' and `)'.  You can use tuples in a similar way to a list:
Wir haben eine Tupel schon früher erwähnt. So ein Tupel ist ein wenig wie eine Liste, aber anstatt der eckigen Klammern werden runde Klammern verwendet---d.h. `(' und `)'. Du kannst Tupel ähnlich verwenden wie eine Liste:

\begin{Verbatim}[frame=single]
>>> t = (1, 2, 3)
>>> print(t[1])
2
\end{Verbatim}

%The main difference is that, unlike lists, tuples can't change, once you've created them.  So if you try to replace a value like we did earlier with the list, you'll get another error message:
Der Hauptunterschied zu Listen ist der, dass sich Tupel nach dem Erstellen nicht mehr ändern können. Wenn du also einen Wert austauschen willst, so wie das bei Listen funktioniert, wirst du bei Tupel eine Fehlermeldung bekommen:

%\begin{listing}
%\begin{verbatim}
%>>> t[0] = 4
%Traceback (most recent call last):
%  File "<stdin>", line 1, in ?
%TypeError: 'tuple' object does not support item assignment
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> t[0] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
\end{Verbatim}

%That doesn't mean you can't change the variable containing the tuple to something else.  For example, this code will work fine:
Das heißt aber nicht, dass du die Variable die das Tupel enthält nicht ändern kannst. Folgendes funktioniert zum Beispiel ganz normal:

%\begin{listing}
%\begin{verbatim}
%>>> myvar = (1, 2, 3)
%>>> myvar = [ 'a', 'list', 'of', 'strings' ]
%\end{verbatim}
%\end{listing}
\begin{Verbatim}[frame=single]
>>> meine_variable = (1, 2, 3)
>>> meine_variable = [ 'Eine', 'Liste', 'von', 'Strings' ]
\end{Verbatim}

%First we create the variable \code{myvar} pointing to a tuple of 3 numbers.  Then we change \code{myvar} to point at a list of strings. This might be a bit confusing at first.  But think of it like lockers in a school.  Each locker has a name tag on it. You put something in the locker, close the door, lock it, then throw away the key.  You then peel the name tag off, wander over to another empty locker, and stick something else in that (but this time you keep the key).  A tuple is like the locked locker.  You can't change what's inside it.  But you can take the label off and stick it on an unlocked locker, and then put stuff inside that locker and take stuff out---that's the list.
Zuerst erzeugen wir die Variable \code{meine\_variable} die auf das Tupel mit den 3 Nummern zeigt. Danach lassen wir \code{meine\_variable} auf eine Liste von Strings zeigen. Das ist vielleicht etwas verwirrend. Aber denke zum Beispiel an Schließfächer mit Namen drauf. Du gibst etwas in ein Fach, sperrst es zu und dann wirfst du den Schlüssel weg. Dann ziehst du den Namen vom Fach ab und klebst den Aufkleber mit dem Namen auf ein leeres Fach. Da gibst du andere Sachen rein, sperrst zu und diesmal behältst du den Schlüssel. Ein Tupel ist wie ein verschlossenes Schließfach. Den Inhalt kann man nicht ändern.  Aber du kannst die Beschriftung runternehmen und auf ein leeres Fach kleben.

%\section{Things to try}
\section{Probiere es aus}

%\emph{In this chapter we saw how to calculate simple mathematical equations using the Python console.  We also saw how brackets can change the result of an equation, by controlling the order that operators are used.  We found out how to tell Python to remember values for later use---using variables---plus how Python uses `strings' for storing text, and lists and tuples, for handling more than one item.}
\emph{In diesem Kapitel haben wir gesehen wie man einfache mathematische Gleichungen mit Hilfe der Python Konsole berechnet. Du hast auch gelernt wie die Verwendung von Klammern das Resultat von Rechnungen beeinflusst in dem die Reihenfolge der Berechnung sich ändert. Du weißt jetzt wie man in Python Werte für späteren Zugriff speichern kann---mit der Verwendung von Variablen---und was `Strings', Listen und Tupel sind.}
\par

%\subsection*{Exercise 1}
\subsection*{Übung 1}
%Make a list of your favourite toys and name it \code{toys}.  Make a list of your favourite foods and name it \code{foods}.  Join these two lists and name the result \code{favourites}.  Finally print the variable \code{favourites}.
Mache eine Liste von deinen Lieblingsspielsachen und nenne die Liste \code{spielsachen}. Mache eine Liste von deinen Lieblingsspeisen und nenne diese Liste \code{speisen}. Verbinde diese zwei Listen und nenne das Ergebnis \code{favoriten}. Verwende print um die Liste der Favoriten auszugeben.

%\subsection*{Exercise 2}
\subsection*{Übung 2}
%If you have 3 boxes containing 25 chocolates, and 10 bags containing 32 sweets, how many sweets and chocolates do you have in total?  (Note: you can do this with one equation with the Python console)
Du hast 3 Schachteln und in jeder sind 25 Schokoladen enthalten. Du hast auch 10 Tüten mit jeweils 32 Süßigkeiten. Wie viele Schokoladen und Süßigkeiten hast du insgesamt? (Hinweis: du kannst diese Rechnung mit der Python Konsole durchführen)

%\subsection*{Exercise 3}
\subsection*{Übung 3}
%Create variables for your first and last name. Now create a string and use placeholders to add your name.
Mache eine Variable für deinen Vornamen und eine Variable für deinen Nachnamen. Erzeuge nun einen String und verwende Platzhalter um deinen Namen auszugeben.

\newpage
